#ifndef AI_ANALYZER_H
#define AI_ANALYZER_H

// 传感器数据结构
typedef struct {
  uint8_t nodeId;
  float temperature;
  float humidity;
  float light;
} SensorData;

// 数据统计结构体
typedef struct {
  float mean;
  float stdDev;
  float min;
  float max;
} DataStats;

class AIAnalyzer {
private:
  // 训练数据缓冲区
  static const int DATA_BUFFER_SIZE = 100;
  float tempBuffer[DATA_BUFFER_SIZE];
  float humidityBuffer[DATA_BUFFER_SIZE];
  float lightBuffer[DATA_BUFFER_SIZE];
  int bufferIndex;
  bool isTrained;
  
  // 统计数据
  DataStats tempStats;
  DataStats humidityStats;
  DataStats lightStats;
  
  // 计算统计数据
  DataStats calculateStats(float* buffer, int size);
  
  // 简单的Z-score异常检测
  bool isAnomaly(float value, DataStats stats, float threshold = 2.0);
  
public:
  AIAnalyzer() {
    bufferIndex = 0;
    isTrained = false;
    
    // 初始化缓冲区
    for (int i = 0; i < DATA_BUFFER_SIZE; i++) {
      tempBuffer[i] = 0.0;
      humidityBuffer[i] = 0.0;
      lightBuffer[i] = 0.0;
    }
  }
  
  void init() {
    // 初始化分析器
    Serial.println("AI分析器初始化完成");
  }
  
  void train(SensorData data) {
    // 将数据添加到缓冲区
    tempBuffer[bufferIndex] = data.temperature;
    humidityBuffer[bufferIndex] = data.humidity;
    lightBuffer[bufferIndex] = data.light;
    
    // 更新缓冲区索引
    bufferIndex = (bufferIndex + 1) % DATA_BUFFER_SIZE;
    
    // 如果缓冲区已满，计算统计数据
    if (bufferIndex == 0 && !isTrained) {
      tempStats = calculateStats(tempBuffer, DATA_BUFFER_SIZE);
      humidityStats = calculateStats(humidityBuffer, DATA_BUFFER_SIZE);
      lightStats = calculateStats(lightBuffer, DATA_BUFFER_SIZE);
      isTrained = true;
      
      Serial.println("AI分析器训练完成");
      Serial.print("温度统计: 均值=");
      Serial.print(tempStats.mean);
      Serial.print(", 标准差=");
      Serial.println(tempStats.stdDev);
      Serial.print("湿度统计: 均值=");
      Serial.print(humidityStats.mean);
      Serial.print(", 标准差=");
      Serial.println(humidityStats.stdDev);
      Serial.print("光照统计: 均值=");
      Serial.print(lightStats.mean);
      Serial.print(", 标准差=");
      Serial.println(lightStats.stdDev);
    }
  }
  
  int detectAnomaly(SensorData data) {
    // 首先训练模型
    train(data);
    
    // 如果还未训练完成，不进行异常检测
    if (!isTrained) {
      return 0; // 无异常
    }
    
    // 检测各个参数的异常
    int anomaly = 0;
    if (isAnomaly(data.temperature, tempStats)) {
      anomaly |= 0x01; // 温度异常
    }
    if (isAnomaly(data.humidity, humidityStats)) {
      anomaly |= 0x02; // 湿度异常
    }
    if (isAnomaly(data.light, lightStats)) {
      anomaly |= 0x04; // 光照异常
    }
    
    return anomaly;
  }
  
  // 预测未来值（简单线性预测）
  float predictNextValue(float* buffer, int size) {
    // 简单的移动平均预测
    float sum = 0;
    int count = min(size, bufferIndex);
    for (int i = 0; i < count; i++) {
      sum += buffer[i];
    }
    return sum / count;
  }
};

// 计算统计数据
DataStats AIAnalyzer::calculateStats(float* buffer, int size) {
  DataStats stats;
  float sum = 0;
  float sumSq = 0;
  
  // 计算均值
  for (int i = 0; i < size; i++) {
    sum += buffer[i];
  }
  stats.mean = sum / size;
  
  // 计算标准差
  for (int i = 0; i < size; i++) {
    sumSq += (buffer[i] - stats.mean) * (buffer[i] - stats.mean);
  }
  stats.stdDev = sqrt(sumSq / size);
  
  // 计算最小值和最大值
  stats.min = buffer[0];
  stats.max = buffer[0];
  for (int i = 1; i < size; i++) {
    if (buffer[i] < stats.min) stats.min = buffer[i];
    if (buffer[i] > stats.max) stats.max = buffer[i];
  }
  
  return stats;
}

// Z-score异常检测
bool AIAnalyzer::isAnomaly(float value, DataStats stats, float threshold) {
  // 如果标准差为0，无法检测异常
  if (stats.stdDev == 0) {
    return false;
  }
  
  // 计算Z-score
  float zScore = abs(value - stats.mean) / stats.stdDev;
  
  // 如果Z-score超过阈值，认为是异常
  return zScore > threshold;
}

#endif